In [2]:
#carregamento de todas as imagens

import cv2
import numpy as np
import matplotlib.pyplot as plt



def exibir_imagens_lado_a_lado(imagens, titulos, figsize=(20, 5), cmap=None):

    # Criar subplots com o número de imagens fornecido
    fig, axs = plt.subplots(1, len(imagens), figsize=figsize)

    # Garantir que axs seja uma lista (caso haja apenas uma imagem)
    if len(imagens) == 1:
        axs = [axs]

    # Exibir cada imagem no subplot correspondente
    for ax, img, titulo in zip(axs, imagens, titulos):
        # Exibir a imagem
        ax.imshow(img, cmap=cmap)
        # Configurar o título e desativar os eixos
        ax.set_title(titulo)
        ax.axis('off')

    plt.tight_layout()
    plt.show()


def carregar_imagens(caminho_base, quantidade, formato="RGB"):
    imagens = []

    for i in range(1, quantidade + 1):
        caminho = f"{caminho_base}{i}.jpg"
        imagem = cv2.imread(caminho)

        if imagem is None:
            print(f"Erro ao carregar imagem {caminho}")
            continue

        # Converter o formato de cor, se necessário
        if formato.upper() == "RGB":
            imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
        elif formato.upper() == "GRAY":
            imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)

        imagens.append(imagem)

    return imagens

canetas = carregar_imagens("canetas/caneta", 10)
borrachas = carregar_imagens("borracha/borracha", 10)
livros = carregar_imagens("livros/livro", 10)

caneta_titulos = [f"Caneta{idx}" for idx in range(1, len(canetas) + 1)]
exibir_imagens_lado_a_lado(canetas, caneta_titulos)

borracha_titulos = [f"Borracha {idx}" for idx in range(1, len(borrachas) + 1)]
exibir_imagens_lado_a_lado(borrachas, borracha_titulos)

livro_titulos = [f"Livro {idx}" for idx in range(1, len(livros) + 1)]
exibir_imagens_lado_a_lado(livros, livro_titulos)
No description has been provided for this image
No description has been provided for this image
No description has been provided for this image
In [3]:
#data augmentation das canetas

# Diretórios para salvar as imagens
C_espelhamento = "canetas_espelhamento/"
C_zoom = "canetas_zoom/"
C_rotacao = "canetas_rotacao/"


# Função para aplicar espelhamento horizontal
def flip_image(image):
    return cv2.flip(image, 1)

# Função para aplicar zoom
def zoom_image(image, zoom_factor=1.2):
    height, width = image.shape[:2]
    center_x, center_y = width // 2, height // 2
    new_width, new_height = int(width / zoom_factor), int(height / zoom_factor)
    start_x = center_x - new_width // 2
    start_y = center_y - new_height // 2
    cropped = image[start_y:start_y + new_height, start_x:start_x + new_width]
    return cv2.resize(cropped, (width, height))

# Função para aplicar rotação
def rotate_image(image, angle):
    height, width = image.shape[:2]
    center = (width // 2, height // 2)
    rotation_matrix = cv2.getRotationMatrix2D(center, angle, 1.0)
    return cv2.warpAffine(image, rotation_matrix, (width, height),borderValue=(255, 255, 255))

# Listas para armazenar imagens transformadas
canetasEspelhamento = []
canetasZoom = []
canetasRotacao = []

# Carregar e processar imagens
for i in range(len(canetas)):

    # Aplicar espelhamento
    imagem_flip = flip_image(canetas[i])
    canetasEspelhamento.append(imagem_flip)
    caminho_flip = f"{C_espelhamento}caneta_espelhamento{i+1}.jpg"
    cv2.imwrite(caminho_flip, cv2.cvtColor(imagem_flip, cv2.COLOR_RGB2BGR))
    
    # Aplicar zoom
    imagem_zoom = zoom_image(canetas[i])
    canetasZoom.append(imagem_zoom)
    caminho_zoom = f"{C_zoom}caneta_zoom{i+1}.jpg"
    cv2.imwrite(caminho_zoom, cv2.cvtColor(imagem_zoom, cv2.COLOR_RGB2BGR))
    # Aplicar rotação
    imagem_rotacao = rotate_image(canetas[i], angle=15)  # Exemplo: rotação de 15 graus
    canetasRotacao.append(imagem_rotacao)
    caminho_rotacao = f"{C_rotacao}caneta_rotacao{i+1}.jpg"
    cv2.imwrite(caminho_rotacao, cv2.cvtColor(imagem_rotacao, cv2.COLOR_RGB2BGR))

canetas_espelhamento = [f"{idx} espelhamento" for idx in range(1, len(canetasEspelhamento) + 1)]
exibir_imagens_lado_a_lado(canetasEspelhamento, canetas_espelhamento)

canetas_zoom = [f"{idx} zoom" for idx in range(1, len(canetasZoom) + 1)]
exibir_imagens_lado_a_lado(canetasZoom, canetas_zoom)

canetas_rotacao = [f"{idx} rotação" for idx in range(1, len(canetasRotacao) + 1)]
exibir_imagens_lado_a_lado(canetasRotacao, canetas_rotacao )
No description has been provided for this image
No description has been provided for this image
No description has been provided for this image
In [4]:
#data augmentation das borrachas

# Diretórios para salvar as imagens
B_espelhamento = "borrachas_espelhamento/"
B_zoom = "borrachas_zoom/"
B_rotacao = "borrachas_rotacao/"

# Listas para armazenar imagens transformadas
borrachasEspelhamento = []
borrachasZoom = []
borrachasRotacao = []

# Carregar e processar imagens
for i in range(len(borrachas)):

    # Aplicar espelhamento
    imagem_flip = flip_image(borrachas[i])
    borrachasEspelhamento.append(imagem_flip)
    caminho_flip = f"{B_espelhamento}borracha_espelhamento{i+1}.jpg"
    cv2.imwrite(caminho_flip, cv2.cvtColor(imagem_flip, cv2.COLOR_RGB2BGR))
    
    # Aplicar zoom
    imagem_zoom = zoom_image(borrachas[i])
    borrachasZoom.append(imagem_zoom)
    caminho_zoom = f"{B_zoom}borracha_zoom{i+1}.jpg"
    cv2.imwrite(caminho_zoom, cv2.cvtColor(imagem_zoom, cv2.COLOR_RGB2BGR))
    
    # Aplicar rotação
    imagem_rotacao = rotate_image(borrachas[i], angle=15)  # Exemplo: rotação de 15 graus
    borrachasRotacao.append(imagem_rotacao)
    caminho_rotacao = f"{B_rotacao}borracha_rotacao{i+1}.jpg"
    cv2.imwrite(caminho_rotacao, cv2.cvtColor(imagem_rotacao, cv2.COLOR_RGB2BGR))

borrachas_espelhamento = [f"{idx} espelhamento" for idx in range(1, len(borrachasEspelhamento) + 1)]
exibir_imagens_lado_a_lado(borrachasEspelhamento, borrachas_espelhamento)

borrachas_zoom = [f"{idx} zoom" for idx in range(1, len(borrachasZoom) + 1)]
exibir_imagens_lado_a_lado(borrachasZoom, borrachas_zoom)

borrachas_rotacao = [f"{idx} rotação" for idx in range(1, len(borrachasRotacao) + 1)]
exibir_imagens_lado_a_lado(borrachasRotacao, borrachas_rotacao )
No description has been provided for this image
No description has been provided for this image
No description has been provided for this image
In [5]:
#data augmentation dos livros

# Diretórios para salvar as imagens
L_espelhamento = "livros_espelhamento/"
L_zoom = "livros_zoom/"
L_rotacao = "livros_rotacao/"


# Listas para armazenar imagens transformadas
livrosEspelhamento = []
livrosZoom = []
livrosRotacao = []

# Carregar e processar imagens
for i in range(len(livros)):

    # Aplicar espelhamento
    imagem_flip = flip_image(livros[i])
    livrosEspelhamento.append(imagem_flip)
    caminho_flip = f"{L_espelhamento}livro_espelhamento{i+1}.jpg"
    cv2.imwrite(caminho_flip, cv2.cvtColor(imagem_flip, cv2.COLOR_RGB2BGR))

    # Aplicar zoom
    imagem_zoom = zoom_image(livros[i])
    livrosZoom.append(imagem_zoom)
    caminho_zoom = f"{L_zoom}livro_zoom{i+1}.jpg"
    cv2.imwrite(caminho_zoom, cv2.cvtColor(imagem_zoom, cv2.COLOR_RGB2BGR))
    
    # Aplicar rotação
    imagem_rotacao = rotate_image(livros[i], angle=15)  # Exemplo: rotação de 15 graus
    livrosRotacao.append(imagem_rotacao)
    caminho_rotacao = f"{L_rotacao}livro_rotacao{i+1}.jpg"
    cv2.imwrite(caminho_rotacao, cv2.cvtColor(imagem_rotacao, cv2.COLOR_RGB2BGR))

livros_espelhamento = [f"{idx} espelhamento" for idx in range(1, len(livrosEspelhamento) + 1)]
exibir_imagens_lado_a_lado(livrosEspelhamento, livros_espelhamento)

livros_zoom = [f"{idx} zoom" for idx in range(1, len(livrosZoom) + 1)]
exibir_imagens_lado_a_lado(livrosZoom, livros_zoom)

livros_rotacao = [f"{idx} rotação" for idx in range(1, len(livrosRotacao) + 1)]
exibir_imagens_lado_a_lado(livrosRotacao, livros_rotacao )
No description has been provided for this image
No description has been provided for this image
No description has been provided for this image
In [4]:
# Função para aplicar zoom inverso
def zoom_out(image, scale=1.5):
    height, width = image.shape[:2]
    new_height, new_width = int(height * scale), int(width * scale)
    
    # Determinar se a imagem é colorida ou em escala de cinza
    if len(image.shape) == 2:  # Escala de cinza
        result = np.full((new_height, new_width), 255, dtype=np.uint8)  # Quadro branco em escala de cinza
    else:  # Colorida
        result = np.full((new_height, new_width, 3), 255, dtype=np.uint8)  # Quadro branco colorido
    
    start_y = (new_height - height) // 2
    start_x = (new_width - width) // 2
    result[start_y:start_y + height, start_x:start_x + width] = image
    return result

# Função para aplicar zoom padrão
def zoom_in(image, zoom_factor=1.2):
    height, width = image.shape[:2]
    center_x, center_y = width // 2, height // 2
    new_width, new_height = int(width / zoom_factor), int(height / zoom_factor)
    start_x = center_x - new_width // 2
    start_y = center_y - new_height // 2
    cropped = image[start_y:start_y + new_height, start_x:start_x + new_width]
    return cv2.resize(cropped, (width, height))
In [3]:
#segmentação das imagens originais
livrosSegmentados = []
canetasSegmentadas = []
borrachasSegmentadas = []

# Diretórios para salvar as imagens
C_original = "imagens_limiarizadas/canetas/original/"
B_original = "imagens_limiarizadas/borrachas/original/"
L_original = "imagens_limiarizadas/livros/original/"


#limiarização da imagens dos livros
for i in range(1, 11):
    caminho = f'livros/livro{i}.jpg'
    imagem = cv2.imread(caminho)

    if imagem is None:
        print(f'erro ao carregar imagem {caminho}')
        continue
    # Convertendo para escala de cinza
    imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
    # Aplicando filtro Gaussiano
    imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
    imagem_blur = zoom_out(imagem_blur)
    # Aplicando limiarização
    _, thresh = cv2.threshold(imagem_blur, 120, 255, cv2.THRESH_BINARY_INV)
    kernel = np.ones((25, 25), np.uint8)
    dilatacao = cv2.dilate(thresh, kernel, iterations=30)
    thresh = cv2.erode(dilatacao, kernel, iterations=40) 
    thresh = cv2.dilate(thresh, kernel, iterations=10) 
    thresh = zoom_in(thresh, zoom_factor=1.5)
    caminho_livro = f"{L_original}livro_original{i}.jpg"
    cv2.imwrite(caminho_livro, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
    livrosSegmentados.append(thresh)  # Armazenar a imagem processada

#limiarização da imagens das borrachas
for i in range(1, 11):
    caminho = f'borracha/borracha{i}.jpg'
    imagem = cv2.imread(caminho)

    if imagem is None:
        print(f'erro ao carregar imagem {caminho}')
        continue
    # Convertendo para escala de cinza
    imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
    # Aplicando filtro Gaussiano
    imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
    # Aplicando limiarização
    _, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
    kernel = np.ones((15, 15), np.uint8)
    dilatacao = cv2.dilate(thresh, kernel, iterations=5)
    thresh = cv2.erode(dilatacao, kernel, iterations=6) 
    caminho_borracha = f"{B_original}borracha_original{i}.jpg"
    cv2.imwrite(caminho_borracha, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
    borrachasSegmentadas.append(thresh)  # Armazenar a imagem processada

#limiarização da imagens das canetas
for i in range(1, 11):  # De 1 a 10
    caminho = f'canetas/caneta{i}.jpg'  
    imagem = cv2.imread(caminho)
    
    if imagem is None:
        print(f"Erro ao carregar a imagem {caminho}")
        continue

    imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
    imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
    _, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
    kernel = np.ones((15, 15), np.uint8)
    dilatacao = cv2.dilate(thresh, kernel, iterations=5)
    thresh = cv2.erode(dilatacao, kernel, iterations=6)
    caminho_caneta = f"{C_original}caneta_original{i}.jpg"
    cv2.imwrite(caminho_caneta, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
    canetasSegmentadas.append(thresh)  


caneta_segmentada = [f"limiarizada{idx}" for idx in range(1, len(canetasSegmentadas) + 1)]
exibir_imagens_lado_a_lado(canetasSegmentadas, caneta_segmentada, cmap='gray')

borracha_segmentada = [f"limiarizada{idx}" for idx in range(1, len(borrachasSegmentadas) + 1)]
exibir_imagens_lado_a_lado(borrachasSegmentadas, borracha_segmentada, cmap='gray')

livro_segmentada = [f"limiarizada{idx}" for idx in range(1, len(livrosSegmentados) + 1)]
exibir_imagens_lado_a_lado(livrosSegmentados, livro_segmentada, cmap='gray')
No description has been provided for this image
No description has been provided for this image
No description has been provided for this image
In [4]:
#segmentação das canetas em data augmentation

canetasEsp = carregar_imagens("canetas_espelhamento/caneta_espelhamento", 10)
canetasZooms = carregar_imagens("canetas_zoom/caneta_zoom", 10)
canetasRota = carregar_imagens("canetas_rotacao/caneta_rotacao", 10)

# Diretórios para salvar as imagens
C_espelhada = "imagens_limiarizadas/canetas/espelhada/"
C_zoom = "imagens_limiarizadas/canetas/zoom/"
C_rotacao = "imagens_limiarizadas/canetas/rotacao/"



canetasSegEspelhamento = []
canetasSegZoom = []
canetasSegRotacao = []

#limiarização da imagens das canetas
for i in range(1, 11):  # De 1 a 10
    caminho = f'canetas_espelhamento/caneta_espelhamento{i}.jpg'  
    imagem = cv2.imread(caminho)
    
    if imagem is None:
        print(f"Erro ao carregar a imagem {caminho}")
        continue

    imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
    imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
    _, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
    kernel = np.ones((15, 15), np.uint8)
    dilatacao = cv2.dilate(thresh, kernel, iterations=5)
    thresh = cv2.erode(dilatacao, kernel, iterations=6)
    caneta_espelhada = f"{C_espelhada}caneta_espelhada{i}.jpg"
    cv2.imwrite(caneta_espelhada, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
    canetasSegEspelhamento.append(thresh)  

#limiarização da imagens das canetas
for i in range(1, 11):  # De 1 a 10
    caminho = f'canetas_zoom/caneta_zoom{i}.jpg'  
    imagem = cv2.imread(caminho)
    
    if imagem is None:
        print(f"Erro ao carregar a imagem {caminho}")
        continue

    imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
    imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
    _, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
    kernel = np.ones((15, 15), np.uint8)
    dilatacao = cv2.dilate(thresh, kernel, iterations=5)
    caneta_zoom = f"{C_zoom}caneta_zoom{i}.jpg"
    cv2.imwrite(caneta_zoom, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
    thresh = cv2.erode(dilatacao, kernel, iterations=6)

    canetasSegZoom.append(thresh)  

#limiarização da imagens das canetas
for i in range(1, 11):  # De 1 a 10
    caminho = f'canetas_rotacao/caneta_rotacao{i}.jpg'  
    imagem = cv2.imread(caminho)
    
    if imagem is None:
        print(f"Erro ao carregar a imagem {caminho}")
        continue

    imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
    imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
    _, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
    kernel = np.ones((15, 15), np.uint8)
    dilatacao = cv2.dilate(thresh, kernel, iterations=5)
    thresh = cv2.erode(dilatacao, kernel, iterations=6)
    caneta_rotacao = f"{C_rotacao}caneta_rotacao{i}.jpg"
    cv2.imwrite(caneta_rotacao, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
    canetasSegRotacao.append(thresh)  


caneta_segEsp = [f"espelhamento {idx}" for idx in range(1, len(canetasSegEspelhamento) + 1)]
exibir_imagens_lado_a_lado(canetasSegEspelhamento, caneta_segEsp, cmap='gray')

caneta_segZoom = [f"zoom {idx}" for idx in range(1, len(canetasSegZoom) + 1)]
exibir_imagens_lado_a_lado(canetasSegZoom, caneta_segZoom, cmap='gray')

caneta_segRota = [f"rotação {idx}" for idx in range(1, len(canetasSegRotacao) + 1)]
exibir_imagens_lado_a_lado(canetasSegRotacao, caneta_segRota, cmap='gray')
No description has been provided for this image
No description has been provided for this image
No description has been provided for this image
In [5]:
#segmentação das borrachas em data augmentation

borrachasEsp = carregar_imagens("borrachas_espelhamento/borracha_espelhamento", 10)
borrachasZooms = carregar_imagens("borrachas_zoom/borracha_zoom", 10)
borrachasRota = carregar_imagens("borrachas_rotacao/borracha_rotacao", 10)

# Diretórios para salvar as imagens
B_espelhada = "imagens_limiarizadas/borrachas/espelhada/"
B_zoom = "imagens_limiarizadas/borrachas/zoom/"
B_rotacao = "imagens_limiarizadas/borrachas/rotacao/"

borrachasSegEspelhamento = []
borrachasSegZoom = []
borrachasSegRotacao = []


#limiarização da imagens das canetas
for i in range(1, 11):  # De 1 a 10
    caminho = f'borrachas_espelhamento/borracha_espelhamento{i}.jpg'  
    imagem = cv2.imread(caminho)
    
    if imagem is None:
        print(f"Erro ao carregar a imagem {caminho}")
        continue

    imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
    imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
    _, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
    kernel = np.ones((15, 15), np.uint8)
    dilatacao = cv2.dilate(thresh, kernel, iterations=5)
    thresh = cv2.erode(dilatacao, kernel, iterations=6)
    borracha_espelhada = f"{B_espelhada}borracha_espelhada{i}.jpg"
    cv2.imwrite(borracha_espelhada, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
    borrachasSegEspelhamento.append(thresh)  

#limiarização da imagens das canetas
for i in range(1, 11):  # De 1 a 10
    caminho = f'borrachas_zoom/borracha_zoom{i}.jpg'  
    imagem = cv2.imread(caminho)
    
    if imagem is None:
        print(f"Erro ao carregar a imagem {caminho}")
        continue

    imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
    imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
    _, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
    kernel = np.ones((15, 15), np.uint8)
    dilatacao = cv2.dilate(thresh, kernel, iterations=5)
    thresh = cv2.erode(dilatacao, kernel, iterations=6)
    borracha_zoom = f"{B_zoom}borracha_zoom{i}.jpg"
    cv2.imwrite(borracha_zoom, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
    borrachasSegZoom.append(thresh)  

#limiarização da imagens das canetas
for i in range(1, 11):  # De 1 a 10
    caminho = f'borrachas_rotacao/borracha_rotacao{i}.jpg'  
    imagem = cv2.imread(caminho)
    
    if imagem is None:
        print(f"Erro ao carregar a imagem {caminho}")
        continue

    imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
    imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
    _, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
    kernel = np.ones((15, 15), np.uint8)
    dilatacao = cv2.dilate(thresh, kernel, iterations=5)
    thresh = cv2.erode(dilatacao, kernel, iterations=6)
    borracha_rotacao = f"{B_rotacao}borracha_rotacao{i}.jpg"
    cv2.imwrite(borracha_rotacao, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
    borrachasSegRotacao.append(thresh)  


borracha_segEsp = [f"espelhamento {idx}" for idx in range(1, len(borrachasSegEspelhamento) + 1)]
exibir_imagens_lado_a_lado(borrachasSegEspelhamento, borracha_segEsp, cmap='gray')

borracha_segZoom = [f"zoom {idx}" for idx in range(1, len(borrachasSegZoom) + 1)]
exibir_imagens_lado_a_lado(borrachasSegZoom, borracha_segZoom, cmap='gray')

borracha_segRota = [f"rotação {idx}" for idx in range(1, len(borrachasSegRotacao) + 1)]
exibir_imagens_lado_a_lado(borrachasSegRotacao, borracha_segRota, cmap='gray')
No description has been provided for this image
No description has been provided for this image
No description has been provided for this image
In [6]:
#segmentação dos livros em data augmentation



livrosEsp = carregar_imagens("livros_espelhamento/livro_espelhamento", 10)
livrosZooms = carregar_imagens("livros_zoom/livro_zoom", 10)
livrosRota = carregar_imagens("livros_rotacao/livro_rotacao", 10)

# Diretórios para salvar as imagens
L_espelhada = "imagens_limiarizadas/livros/espelhada/"
L_zoom = "imagens_limiarizadas/livros/zoom/"
L_rotacao = "imagens_limiarizadas/livros/rotacao/"

livrosSegEspelhamento = []
livrosSegZoom = []
livrosSegRotacao = []

#limiarização da imagens das canetas
for i in range(1, 11):  # De 1 a 10
    caminho = f'livros_espelhamento/livro_espelhamento{i}.jpg'  
    imagem = cv2.imread(caminho)
    
    if imagem is None:
        print(f"Erro ao carregar a imagem {caminho}")
        continue

    imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
    imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
    imagem_blur = zoom_out(imagem_blur)
    _, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
    
    kernel = np.ones((25, 25), np.uint8)
    dilatacao = cv2.dilate(thresh, kernel, iterations=30)
    thresh = cv2.erode(dilatacao, kernel, iterations=40) 
    thresh = cv2.dilate(thresh, kernel, iterations=10)
    thresh = zoom_in(thresh, zoom_factor=1.5)
    livro_espelhada = f"{L_espelhada}livro_espelhada{i}.jpg"
    cv2.imwrite(livro_espelhada, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
    livrosSegEspelhamento.append(thresh)  

#limiarização da imagens das canetas
for i in range(1, 11):  # De 1 a 10
    caminho = f'livros_zoom/livro_zoom{i}.jpg'  
    imagem = cv2.imread(caminho)
    
    if imagem is None:
        print(f"Erro ao carregar a imagem {caminho}")
        continue

    imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
    imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
    imagem_blur = zoom_out(imagem_blur)

    _, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
    
    kernel = np.ones((25, 25), np.uint8)
    dilatacao = cv2.dilate(thresh, kernel, iterations=30)
    thresh = cv2.erode(dilatacao, kernel, iterations=40) 
    thresh = cv2.dilate(thresh, kernel, iterations=10) 
    thresh = zoom_in(thresh, zoom_factor=1.5)
    livro_zoom = f"{L_zoom}livro_zoom{i}.jpg"
    cv2.imwrite(livro_zoom, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
    livrosSegZoom.append(thresh)  

#limiarização da imagens das canetas
for i in range(1, 11):  # De 1 a 10
    caminho = f'livros_rotacao/livro_rotacao{i}.jpg'  
    imagem = cv2.imread(caminho)
    
    if imagem is None:
        print(f"Erro ao carregar a imagem {caminho}")
        continue

    imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
    imagem_blur = cv2.GaussianBlur(imagem, (5, 5), 0)
    imagem_blur = zoom_out(imagem_blur)
    _, thresh = cv2.threshold(imagem_blur, 125, 255, cv2.THRESH_BINARY_INV)
    
    kernel = np.ones((25, 25), np.uint8)
    dilatacao = cv2.dilate(thresh, kernel, iterations=30)
    thresh = cv2.erode(dilatacao, kernel, iterations=40) 
    thresh = cv2.dilate(thresh, kernel, iterations=10)
    thresh = zoom_in(thresh, zoom_factor=1.5)
    livro_rotacao = f"{L_rotacao}livro_rotacao{i}.jpg"
    cv2.imwrite(livro_rotacao, cv2.cvtColor(thresh, cv2.COLOR_RGB2BGR))
    livrosSegRotacao.append(thresh)  


livro_segEsp = [f"espelhamento {idx}" for idx in range(1, len(livrosSegEspelhamento) + 1)]
exibir_imagens_lado_a_lado(livrosSegEspelhamento, livro_segEsp, cmap='gray')

livro_segZoom = [f"zoom {idx}" for idx in range(1, len(livrosSegZoom) + 1)]
exibir_imagens_lado_a_lado(livrosSegZoom, livro_segZoom, cmap='gray')

livro_segRota = [f"rotação {idx}" for idx in range(1, len(livrosSegRotacao) + 1)]
exibir_imagens_lado_a_lado(livrosSegRotacao, livro_segRota, cmap='gray')
No description has been provided for this image
No description has been provided for this image
No description has been provided for this image
In [1]:
import cv2
import numpy as np
from matplotlib import pyplot as plt

# Load the image
image_path = 'imagem_com_fronteira_livrosSegZoom922.jpg'
image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

# Binarize the image
_, imagem_bin = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)

def seguidor_de_fronteira(imagem):
  contornos, _ = cv2.findContours(imagem, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
  if not contornos:
    return imagem
  maior_contorno = max(contornos, key=cv2.contourArea)
  return maior_contorno

def destacar_fronteira(imagem, contorno):
  imagem_com_fronteira = imagem.copy()
  cv2.drawContours(imagem_com_fronteira, [contorno], -1, (255,0,0), 20) # BGR (vermelho)
  return imagem_com_fronteira

contorno = seguidor_de_fronteira(imagem_bin)
imagem_colorida = cv2.cvtColor(imagem_bin, cv2.COLOR_GRAY2BGR)
imagem_com_fronteira = destacar_fronteira(imagem_colorida, contorno)

plt.imshow(imagem_com_fronteira)
plt.title('Imagem com Fronteira em Vermelho')
plt.show()
No description has been provided for this image
In [2]:
import math

def resample(contorno, num_pontos):
    perimetro = 0
    for i in range(len(contorno)):
        if i == len(contorno) - 1:
            dx = contorno[0][0][0] - contorno[i][0][0]
            dy = contorno[0][0][1] - contorno[i][0][1]
        else:
            dx = contorno[i+1][0][0] - contorno[i][0][0]
            dy = contorno[i+1][0][1] - contorno[i][0][1]
        perimetro += math.sqrt(dx**2 + dy**2)

    intervalo = perimetro / num_pontos
    pontos_reamostrados = []
    distancia_acumulada = 0
    i = 0

    for j in range(num_pontos):
        distancia_alvo = intervalo * j

        while distancia_acumulada < distancia_alvo:
            if i == len(contorno) - 1:
                dx = contorno[0][0][0] - contorno[i][0][0]
                dy = contorno[0][0][1] - contorno[i][0][1]
            else:
                dx = contorno[i+1][0][0] - contorno[i][0][0]
                dy = contorno[i+1][0][1] - contorno[i][0][1]

            segmento_comprimento = math.sqrt(dx**2+dy**2)

            if distancia_acumulada + segmento_comprimento < distancia_alvo:
                distancia_acumulada += segmento_comprimento
                i = (i+1)%len(contorno)
            else:
                #Interpolação linear
                t = (distancia_alvo - distancia_acumulada) / segmento_comprimento
                x = contorno[i][0][0] + t * dx
                y = contorno[i][0][1] + t * dy
                pontos_reamostrados.append([int(x),int(y)])
                break

    return np.array(pontos_reamostrados).reshape(-1, 1, 2)

contorno_reamostrado = resample(contorno, 30)  # Exemplo: 16 pontos
imagem_reamostrada = destacar_fronteira(imagem_colorida.copy(), contorno_reamostrado)
plt.imshow(imagem_reamostrada)
plt.title('Imagem com Contorno Reamostrado')
plt.show()
No description has been provided for this image
In [3]:
def gerar_codigo_cadeia(contorno):
  code = []
  for i in range(len(contorno)):
    if i == len(contorno)-1:
      dx = contorno[0][0][0] - contorno[i][0][0]
      dy = contorno[0][0][1] - contorno[i][0][1]
    else:
      dx = contorno[i+1][0][0] - contorno[i][0][0]
      dy = contorno[i+1][0][1] - contorno[i][0][1]

    if dx == 0 and dy < 0:
      code.append(0)
    elif dx > 0 and dy < 0:
      code.append(1)
    elif dx > 0 and dy == 0:
      code.append(2)
    elif dx > 0 and dy > 0:
      code.append(3)
    elif dx == 0 and dy > 0:
      code.append(4)
    elif dx < 0 and dy > 0:
      code.append(5)
    elif dx < 0 and dy == 0:
      code.append(6)
    elif dx < 0 and dy < 0:
      code.append(7)

  return code


codigo_cadeia = gerar_codigo_cadeia(contorno_reamostrado)
print("Código de cadeia:", codigo_cadeia)
Código de cadeia: [6, 6, 7, 5, 3, 3, 3, 3, 4, 4, 5, 5, 3, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 7, 5]
In [4]:
def normalizar_codigo_cadeia(codigo_cadeia):
    min_codigo = codigo_cadeia[:]
    min_valor = int("".join(map(str, codigo_cadeia))) # Converte a lista para string e em seguida para int

    for i in range(len(codigo_cadeia)):
        codigo_rotacionado = codigo_cadeia[i:] + codigo_cadeia[:i]
        valor_atual = int("".join(map(str, codigo_rotacionado)))
        if valor_atual < min_valor:
            min_valor = valor_atual
            min_codigo = codigo_rotacionado

    return min_codigo


codigo_cadeia_normalizado = normalizar_codigo_cadeia(codigo_cadeia)
print("Código de cadeia normalizado:", codigo_cadeia_normalizado)
Código de cadeia normalizado: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 7, 5, 6, 6, 7, 5, 3, 3, 3, 3, 4, 4, 5, 5, 3, 1, 1, 1, 2]
In [6]:
def processar_imagem(imagem, num_pontos):
    contorno = seguidor_de_fronteira(imagem)
    contorno_reamostrado = resample(contorno, num_pontos)
    codigo_cadeia = gerar_codigo_cadeia(contorno_reamostrado)
    codigo_cadeia_normalizado = normalizar_codigo_cadeia(codigo_cadeia)
    return codigo_cadeia_normalizado



num_pontos_finais = 30 #Quantidade de pontos finais desejados
codigo_normalizado = processar_imagem(imagem_bin, num_pontos_finais)
print("Código de cadeia normalizado:", codigo_normalizado)
Código de cadeia normalizado: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 7, 5, 6, 6, 7, 5, 3, 3, 3, 3, 4, 4, 5, 5, 3, 1, 1, 1, 2]
In [7]:
import pandas as pd
import random

# ... (código anterior permanece inalterado)

"imagens_limiarizadas/livros/espelhada/"

resultados = []
num_imagens = 10
num_pontos_finais = 30

for i in range(num_imagens):
    caneta_original = cv2.imread(f"imagens_limiarizadas/canetas/original/caneta_original{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
    caneta_espelhada = cv2.imread(f"imagens_limiarizadas/canetas/espelhada/caneta_espelhada{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
    caneta_zoom = cv2.imread(f"imagens_limiarizadas/canetas/zoom/caneta_zoom{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
    caneta_rotacao = cv2.imread(f"imagens_limiarizadas/canetas/rotacao/caneta_rotacao{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
    
    codigo_caneta_original = processar_imagem(caneta_original, num_pontos_finais)
    resultados.append({'tipo': 'caneta', 'codigo': codigo_caneta_original, 'imagem': caneta_original})
    
    codigo_caneta_espelhada = processar_imagem(caneta_espelhada, num_pontos_finais)
    resultados.append({'tipo': 'caneta', 'codigo': codigo_caneta_espelhada, 'imagem': caneta_espelhada})

    codigo_caneta_zoom = processar_imagem(caneta_zoom, num_pontos_finais)
    resultados.append({'tipo': 'caneta', 'codigo': codigo_caneta_zoom, 'imagem': caneta_zoom})

    codigo_caneta_rotacao = processar_imagem(caneta_rotacao, num_pontos_finais)
    resultados.append({'tipo': 'caneta', 'codigo': codigo_caneta_rotacao, 'imagem': caneta_rotacao})

    
for i in range(num_imagens):
    borracha_original = cv2.imread(f"imagens_limiarizadas/borrachas/original/borracha_original{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
    borracha_espelhada = cv2.imread(f"imagens_limiarizadas/borrachas/espelhada/borracha_espelhada{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
    borracha_zoom = cv2.imread(f"imagens_limiarizadas/borrachas/zoom/borracha_zoom{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
    borracha_rotacao = cv2.imread(f"imagens_limiarizadas/borrachas/rotacao/borracha_rotacao{i+1}.jpg", cv2.IMREAD_GRAYSCALE)

    codigo_borracha_original = processar_imagem(borracha_original, num_pontos_finais)
    resultados.append({'tipo': 'borracha', 'codigo': codigo_borracha_original, 'imagem': borracha_original})

    codigo_borracha_espelhada = processar_imagem(borracha_espelhada, num_pontos_finais)
    resultados.append({'tipo': 'borracha', 'codigo': codigo_borracha_espelhada, 'imagem': borracha_espelhada})

    codigo_borracha_zoom = processar_imagem(borracha_zoom, num_pontos_finais)
    resultados.append({'tipo': 'borracha', 'codigo': codigo_borracha_zoom, 'imagem': borracha_zoom})

    codigo_borracha_rotacao = processar_imagem(borracha_rotacao, num_pontos_finais)
    resultados.append({'tipo': 'borracha', 'codigo': codigo_borracha_rotacao, 'imagem': borracha_rotacao})

for i in range(num_imagens):

    livro_original = cv2.imread(f"imagens_limiarizadas/livros/original/livro_original{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
    livro_espelhada = cv2.imread(f"imagens_limiarizadas/livros/espelhada/livro_espelhada{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
    livro_zoom = cv2.imread(f"imagens_limiarizadas/livros/zoom/livro_zoom{i+1}.jpg", cv2.IMREAD_GRAYSCALE)
    livro_rotacao = cv2.imread(f"imagens_limiarizadas/livros/rotacao/livro_rotacao{i+1}.jpg", cv2.IMREAD_GRAYSCALE)


    codigo_livro_original = processar_imagem(livro_original, num_pontos_finais)
    resultados.append({'tipo': 'livro', 'codigo': codigo_livro_original, 'imagem': livro_original})

    codigo_livro_espelhada = processar_imagem(livro_espelhada, num_pontos_finais)
    resultados.append({'tipo': 'livro', 'codigo': codigo_livro_espelhada, 'imagem': livro_espelhada})

    codigo_livro_zoom = processar_imagem(livro_zoom, num_pontos_finais)
    resultados.append({'tipo': 'livro', 'codigo': codigo_livro_zoom, 'imagem': livro_zoom})

    codigo_livro_rotacao = processar_imagem(livro_rotacao, num_pontos_finais)
    resultados.append({'tipo': 'livro', 'codigo': codigo_livro_rotacao, 'imagem': livro_rotacao})


df_resultados = pd.DataFrame(resultados)
In [8]:
df_resultados = df_resultados.drop(columns=['imagem'])

for i in range(len(df_resultados['codigo'][0])):
    df_resultados[f'codigo_{i}'] = df_resultados['codigo'].apply(lambda x: x[i])

df_resultados = df_resultados.drop(columns=['codigo'])

df_resultados
Out[8]:
tipo codigo_0 codigo_1 codigo_2 codigo_3 codigo_4 codigo_5 codigo_6 codigo_7 codigo_8 ... codigo_19 codigo_20 codigo_21 codigo_22 codigo_23 codigo_24 codigo_25 codigo_26 codigo_27 codigo_28
0 caneta 1 1 1 1 1 1 1 7 7 ... 5 3 5 5 5 5 3 1 1 7
1 caneta 1 7 7 7 7 5 5 5 5 ... 3 1 7 7 7 7 7 7 7 7
2 caneta 1 1 1 1 1 1 1 1 1 ... 5 5 4 4 5 5 5 5 5 3
3 caneta 1 7 7 7 7 7 7 7 7 ... 3 3 3 3 3 3 3 3 3 3
4 caneta 1 1 1 1 1 1 1 1 1 ... 5 5 5 5 5 5 5 3 1 7
... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
115 livro 1 1 1 1 1 1 7 7 7 ... 5 3 3 3 3 3 3 3 3 3
116 livro 0 1 1 1 1 1 1 7 7 ... 3 3 1 1 2 1 1 1 1 1
117 livro 0 1 1 1 1 7 7 5 6 ... 3 3 3 2 3 3 3 1 7 7
118 livro 0 1 1 1 1 7 5 6 7 ... 3 1 1 2 1 1 1 1 1 1
119 livro 1 1 1 1 1 1 7 7 7 ... 5 3 3 3 3 3 3 3 3 3

120 rows × 30 columns

In [ ]: